home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 405_01 / Discussion / partx-sun-attachment0 < prev   
Encoding:
Text File  |  1993-07-17  |  8.2 KB  |  314 lines
  1. ----------
  2. X-Sun-Data-Type: text
  3. X-Sun-Data-Description: text
  4. X-Sun-Data-Name: text
  5. X-Sun-Content-Lines: 114
  6.  
  7.  
  8. > From root Thu Jul 15 20:00:27 1993
  9. > >From ramanand@thor.ece.uc.EDU Thu Jul 15 20:00:27 1993
  10. > Date: 15 Jul 93 13:57:27-0400
  11. > From: John Holmes Sr <ramanand@thor.ece.uc.EDU>
  12. > Subject: flex++/bison++
  13. > To: coetmeur@icdc.fr
  14. > MIME-version: 1.0
  15. > Content-Type> : > text/plain> ; > charset=US-ASCII> 
  16. > Content-transfer-encoding: 7bit
  17. > 
  18. > Hello Alain,
  19. > 
  20. > I recently ported the flex++/bison++ software that you have put up on the
  21. > ftp server under comp.compilers. 
  22. > 
  23. > First of all I would like to complement you on a job well underakten. The
  24. > documentation is quite beneficial. 
  25. > 
  26. > However I have been having some problems with generating multiple parsers
  27. > in the same executable. It is quite possible that my understanding of the
  28. > full capabilities of the notions of class etc. are not quite up to the
  29. > mark. I would appreciate any help you can provide.
  30. > 
  31. > 
  32. > I have tried the following approach. If there is a better way, please let
  33. > me know.
  34. > 
  35. > 
  36. >     Prepare two bison++ files. Each of them declares a different class
  37. >     for the parser. Each of them declares its LEX_BODY as = 0 (i.e. a
  38. >     pure virtual function). Prepare two flex++ files. Each of them
  39. >     inherits the properties of the corresponding parser class and defines
  40. >     the lexical analyser functions. 
  41. > 
  42. >     So I now have two sets of header files. 
  43. > 
  44. >         a. parser1.h and lex1.h
  45. >         b. parser2.h and lex2.h
  46. > 
  47. >     
  48. > 
  49. > 
  50. > Each set of parser/lexical analyser individually compiles correctly
  51. > with the latest gnu c++  compiler. However, if I try to include both
  52. > the lexical header files (lex1.c and lex2.c) in the main file, I get syntax
  53. > errors. The reason is in the first two lines of these header files. They
  54. > are duplicated here below:
  55. > 
  56. >     #ifndef FLEX_HEADER_lex__h
  57. >     #define FLEX_HEADER_lex__h
  58. >     ...
  59. >     ...
  60. > 
  61. > 
  62. > Since both these files define the same symbol FLEX_HEADER_lex__h,
  63. > obviously the second time that I include the header file, it is ignored
  64. > by the preprocessor. 
  65. > 
  66. > Can you give me some solutions to this. Either I could somehow rename this
  67. > symbol , or you have  a better class hierarchy that I am unaware of
  68. > currently. 
  69. > 
  70.  
  71.  
  72.  
  73.     The way we can use multiple parser or scanner is by changing
  74.    the name of the scanner/parser with the directive %name. it is
  75.    ESSENTIAL. By default and for compatibility the name is set to 'lex'
  76.    and 'parse', but it should be changed to a different name for each
  77.    parser/scanner. Further, the scanner and parser must not have the
  78.    same name. the name given is used as the class name, and to build
  79.    many symbol names. So you should give a %name directive, before any
  80.    other in the flex++ and bison++ files. If all the header use the
  81.    symbol FLEX_HEADER_lex__h if shoul mean that they use the same
  82.    %name. If it is not the case, it is a very important bug. I was not
  83.    able to reproduce it with the data I have.
  84.  
  85.     The way to comunicate between the scanner and the parser is not
  86.    a trivial choic, and at our site we discussed much about it. The
  87.    problems are complex since the scanner use parser constant for token
  88.    ID, the parser use the scanner function as token furnisher, and so
  89.    on...
  90.  
  91.     The way that we used is to create a derived class from the
  92.    parser class, containing the scanner itself, and redefining the
  93.    token reader function of the parser to call the scanner function of
  94.    the scanner. It seems good for many reasons:
  95.  
  96.        - the compiler (ie parser+scanner) IS essentially a PARSER,
  97.          that USE a particular SCANNER to give tokens.
  98.  
  99.        - the intermediate function that give tokens from the
  100.          scanner to the parser is a good place to put trace, and
  101.          management function (line count...)
  102.  
  103.      The design was so important to explain to new users in our
  104.     site, that I decided to build a template of compiler that is a
  105.     base to modify. It should be present in misc++, but I send it as
  106.     attachment (4 files).
  107.  
  108.     I am concient that the documentation I have given is very
  109.     technical, and assume a deep knowledge of flex, bison, C/C++, and
  110.     some design experiences.
  111.  
  112.  
  113.     Please tell me was is the result of your new try, successful or not.
  114.  
  115.     Hoping I could help you, Best regard.
  116.  
  117.  
  118.     Alain Coetmeur
  119.  
  120.  
  121. ----------
  122. X-Sun-Data-Type: rdti-source-makefile
  123. X-Sun-Data-Name: makefile
  124. X-Sun-Content-Lines: 28
  125.  
  126.  
  127.  
  128. .SUFFIXES : .cc .y .l $(SUFFIXES)
  129.  
  130. .cc.o :
  131.     CC   -I$(CENTERCCLIBDIR)/incl -c  $*.cc
  132.  
  133. .y.cc :
  134.     bison++ -d  -o $*.cc -h $*.h  $*.y
  135. .l.cc :
  136.     flex++    -h$*.h -o$*.cc $*.l
  137. .y.h :
  138.     bison++ -d  -o $*.cc -h $*.h  $*.y
  139. .l.h :
  140.     flex++    -h$*.h -o$*.cc $*.l
  141.  
  142. all : compiler
  143.  
  144. MyCompiler.o : MyCompiler.cc MyParser.h MyScanner.h
  145.  
  146. MyParser.o : MyParser.cc MyParser.h
  147.  
  148. MyScanner.o : MyScanner.cc MyScanner.h MyParser.h
  149.  
  150.  
  151. compiler : MyCompiler.o MyParser.o MyScanner.o
  152.     CC  -o $@ MyCompiler.o MyParser.o MyScanner.o
  153.  
  154. ----------
  155. X-Sun-Data-Type: rdtq-source-l
  156. X-Sun-Data-Name: MyScanner.l
  157. X-Sun-Content-Lines: 42
  158.  
  159. /* %Z% %M% %Y% %Q% %I% %E% %U% (%F%) */
  160. /*
  161.  * Nom du Fichier :     |>nom_fichier<|
  162.  * Titre :         |>Titre<|
  163.  * Auteur:        |>auteur<|        
  164.  * Date de creation :    |>dateCreation<|
  165.  */
  166. /* Description :
  167.  *    Document de reference : |>doc<|
  168.  *    Objet : |>objet<|
  169.  *
  170.  */
  171. /* 
  172.  * historique :
  173.  * |>date<|    |>auteur<|    |>objet<|
  174.  */
  175. /* -------------- declaration section -------------- */
  176. %name MyScanner
  177.  
  178. %define LEX_PARAM YY_MyParser_STYPE *val,YY_MyParser_LTYPE *loc
  179. %define MEMBERS public: int theLine,theColumn;
  180. %define CONSTRUCTOR_INIT : theLine(1),theColumn(1)
  181. %header{ 
  182. #include "MyParser.h"
  183. %}
  184.  
  185. %{
  186. static char SccsId[]="%Z% %M% %Y% %Q% %I% %E% %U% (%F%)";
  187. %}
  188.  
  189. /* -------------- rules section -------------- */
  190. SPACES [ \t]+
  191. %%
  192. "\n"    {val->ctype='\n';
  193.          theLine++;theColumn=1;
  194.          return MyParser::EOL_TOKEN; }
  195. .    {
  196.          val->ctype=yytext[0];
  197.          theColumn++;
  198.          return MyParser::CHAR_TOKEN; }
  199. <<EOF>> { yyterminate();}
  200. %%
  201. ----------
  202. X-Sun-Data-Type: rdtq-source-y
  203. X-Sun-Data-Name: MyParser.y
  204. X-Sun-Content-Lines: 50
  205.  
  206. /* %Z% %M% %Y% %Q% %I% %E% %U% (%F%) */
  207. /*
  208.  * Nom du Fichier :     |>nom_fichier<|
  209.  * Titre :         |>Titre<|
  210.  * Auteur:        |>auteur<|
  211.  * Date de creation :    |>dateCreation<|
  212.  */
  213. /* Description :
  214.  *    Document de reference : |>doc<|
  215.  *    Objet : |>objet<|
  216.  *
  217.  */
  218. /*
  219.  * historique :
  220.  * |>date<|    |>auteur<|    |>objet<|
  221.  */
  222. /* -------------- declaration section -------------- */
  223.  
  224. %name MyParser
  225. %define LSP_NEEDED
  226. %define ERROR_BODY =0
  227. %define LEX_BODY =0
  228. %header{
  229. #include <stdio.h>
  230. %}
  231.  
  232. %union {
  233.     int itype;    /* for count */
  234.     char ctype;    /* for char */
  235.     }
  236. %token <ctype> EOL_TOKEN CHAR_TOKEN
  237. %type <itype> file line lines chars
  238. %start file
  239.  
  240. /* -------------- rules section -------------- */
  241. /* Sample parser. Does count Chars in a line, and lines in file */
  242. %%
  243. file    : lines
  244.     {printf("nlines=%d\n",$1); /* show line count */}
  245.     ;
  246. lines     : line {$$=1; /* first line of all */}
  247.     | lines line {$$=$1+1;    /* count one more line */}
  248.     ;
  249. line     : chars EOL_TOKEN {$$=$1;printf("nchars=%d\n",$1); /* show char count */}
  250.     ;
  251. chars    : CHAR_TOKEN { $$=1;/* first char of line */}
  252.     | chars CHAR_TOKEN {$$=$1+1; /* count one more char */}
  253.     ;
  254. %%
  255. /* -------------- body section -------------- */
  256. ----------
  257. X-Sun-Data-Type: rdtq-source-cc
  258. X-Sun-Data-Name: MyCompiler.cc
  259. X-Sun-Content-Lines: 52
  260.  
  261. static char SccsId[]="%Z% %M% %Y% %Q% %I% %E% %U% (%F%)";
  262. //
  263. // Nom du Fichier :     |>nom_fichier<|
  264. // Titre :         |>Titre<|
  265. // Auteur:        |>auteur<|        
  266. // Date de creation :    |>dateCreation<|
  267. //
  268. // Description :
  269. //    Document de reference : |>doc<|
  270. //    Objet : |>objet<|
  271. //
  272. //
  273. // 
  274. // historique :
  275. // |>date<|    |>auteur<|    |>objet<|
  276. //
  277. #include "MyScanner.h"
  278. #include "MyParser.h"
  279.  
  280. class MyCompiler : public MyParser
  281. {private:
  282.  MyScanner theScanner;
  283.  public:
  284.  virtual int yylex();
  285.  virtual void yyerror(char *m);
  286.  MyCompiler() 
  287.   {};
  288. };
  289.  
  290. int MyCompiler::yylex()
  291. {
  292.  yylloc.first_line=theScanner.theLine;
  293.  yylloc.first_column=theScanner.theColumn;
  294.  int token=theScanner.yylex(&yylval,&yylloc);
  295.  yylloc.last_line=theScanner.theLine;
  296.  yylloc.last_column=theScanner.theColumn;
  297.  yylloc.text=(char *)theScanner.yytext;
  298.  return token;
  299. }
  300.  
  301. void MyCompiler::yyerror(char *m)
  302. { fprintf(stderr,"%d: %s at token '%s'\n",yylloc.first_line, m,yylloc.text);
  303. }
  304.  
  305. int main(int argc,char **argv)
  306. {
  307.  MyCompiler aCompiler;
  308.  int result=aCompiler.yyparse();
  309.  printf("Resultat Parsing=%s\n",result?"Erreur":"OK");
  310.  return 0;
  311. };
  312.  
  313.  
  314.